package com.shop.product.service.impl;

import com.shop.common.core.utils.DateUtils;
import com.shop.common.redis.service.RedisService;
import com.shop.common.security.utils.SecurityUtils;

import com.shop.product.constant.ProductConstant;
import com.shop.product.domain.MallProductRuleInfo;
import com.shop.product.domain.MallProductTypeInfo;
import com.shop.product.domain.res.MallProductTypeInfoVo;
import com.shop.product.mapper.MallProductTypeInfoMapper;
import com.shop.product.service.MallProductTypeInfoService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Service
public class MallProductTypeInfoServiceImpl implements MallProductTypeInfoService {
    @Autowired
    MallProductTypeInfoMapper mallProductTypeInfoMapper;
    @Autowired
    private RedisService redisService;
    public static final Long PARENT_ID=0L;
    @Override
    public List<MallProductTypeInfo> selectMallProductTypeInfoList(MallProductTypeInfo mallProductTypeInfo) {



        return mallProductTypeInfoMapper.selectMallProductTypeInfoList(mallProductTypeInfo);
    }

    @Override
    public MallProductTypeInfo selectMallProductTypeInfoByCatId(Long catId) {

        return mallProductTypeInfoMapper.selectMallProductTypeInfoByCatId(catId);
    }

    @Override
    public int insertMallProductTypeInfo(MallProductTypeInfo mallProductTypeInfo) {


        return mallProductTypeInfoMapper.insertMallProductTypeInfo(mallProductTypeInfo);
    }

    @Override
    public int updateMallProductTypeInfo(MallProductTypeInfo mallProductTypeInfo) {
        return mallProductTypeInfoMapper.updateMallProductTypeInfo(mallProductTypeInfo);
    }

    @Override
    public int deleteMallProductTypeInfoByCatIds(Long[] catIds) {
        return mallProductTypeInfoMapper.deleteMallProductTypeInfoByCatIds(catIds);
    }

    @Override
    public List<MallProductTypeInfoVo> listAll(MallProductTypeInfo mallProductTypeInfo) {
        // 查询符合条件的商品类型信息列表
        List<MallProductTypeInfo> mallProductTypeInfos = selectMallProductTypeInfoList(mallProductTypeInfo);

        // 对查询到的商品类型信息列表进行处理，筛选出顶级父类ID为PARENT_ID的节点，并转换为VO对象列表
        List<MallProductTypeInfoVo> returnList = mallProductTypeInfos.stream()
                .filter(item -> PARENT_ID.equals(item.getParentId()))  // 过滤出顶级父类ID为PARENT_ID的节点
                .map(newItem -> {
                    // 创建新的VO对象，并复制属性
                    MallProductTypeInfoVo mallProductTypeInfoVo = new MallProductTypeInfoVo();
                    BeanUtils.copyProperties(newItem, mallProductTypeInfoVo);
                    return mallProductTypeInfoVo;
                })
                .map(mallProductTypeInfoVo -> {
                    // 设置子节点列表
                    mallProductTypeInfoVo.setChildrenList(packageChildrenList(mallProductTypeInfoVo, mallProductTypeInfos));
                    return mallProductTypeInfoVo;
                })
                .collect(Collectors.toList());  // 将处理后的VO对象收集为列表
        // 返回处理后的VO对象列表
        return returnList;
    }

    @Override
    public List<MallProductTypeInfoVo> listAll1(MallProductTypeInfo mallProductTypeInfo) {
        // 构建缓存key
        String key = ProductConstant.CACHE_PREFIX + "category:";

        // 检查缓存中是否存在该key对应的数据
        Boolean hasKey = redisService.hasKey(key);
        if (hasKey) {
            // 如果缓存中存在数据，则直接从缓存中获取并返回
            return redisService.getCacheList(key);
        }

        // 如果缓存中不存在数据，则执行以下操作

        // 初始化返回的商品类型信息VO列表
        List<MallProductTypeInfoVo> returnMallProductList = new ArrayList<>();

        // 查询数据库，获取所有符合条件的商品类型信息列表
        List<MallProductTypeInfo> mallProductTypeInfos = selectMallProductTypeInfoList(mallProductTypeInfo);

        // 遍历商品类型信息列表，筛选出顶级父类ID为PARENT_ID的节点，并转换为VO对象添加到返回列表中
        for (MallProductTypeInfo productTypeInfo : mallProductTypeInfos) {
            Long parentCid = productTypeInfo.getParentId();
            if (PARENT_ID.equals(parentCid)) {
                // 创建新的VO对象，并复制属性
                MallProductTypeInfoVo mallProductTypeInfoVo = new MallProductTypeInfoVo();
                BeanUtils.copyProperties(productTypeInfo, mallProductTypeInfoVo);
                returnMallProductList.add(mallProductTypeInfoVo);
            }
        }

        // 遍历返回的商品类型信息VO列表，为每个顶级节点设置子节点列表
        for (MallProductTypeInfoVo mallProductTypeInfoVo : returnMallProductList) {
            List<MallProductTypeInfoVo> childrenList = packageChildrenList1(mallProductTypeInfoVo, mallProductTypeInfos);
            mallProductTypeInfoVo.setChildrenList(childrenList);
        }

        // 将处理后的商品类型信息VO列表存入缓存
        redisService.setCacheList(key, returnMallProductList);

        // 设置缓存过期时间
        redisService.expire(key, ProductConstant.TTL, TimeUnit.MILLISECONDS);

        // 返回处理后的商品类型信息VO列表
        return returnMallProductList;
    }

    private List<MallProductTypeInfoVo> packageChildrenList1(MallProductTypeInfoVo mallProductTypeInfoVo, List<MallProductTypeInfo> mallProductTypeInfos) {
        // 初始化返回的子节点VO列表
        List<MallProductTypeInfoVo> returnList = new ArrayList<>();

        // 获取当前节点的ID作为父节点ID
        Long parentId = mallProductTypeInfoVo.getId();

        // 遍历商品类型信息列表，查找当前节点的直接子节点
        for (MallProductTypeInfo mallProductTypeInfo : mallProductTypeInfos) {
            // 获取每个商品类型信息的父节点ID
            Long parentCid = mallProductTypeInfo.getParentId();

            // 如果找到当前节点的直接子节点
            if (parentId.equals(parentCid)) {
                // 创建新的子节点VO对象，并复制属性
                MallProductTypeInfoVo newMallProductTypeInfoVo = new MallProductTypeInfoVo();
                BeanUtils.copyProperties(mallProductTypeInfo, newMallProductTypeInfoVo);

                // 递归调用，为当前子节点设置其子节点列表
                newMallProductTypeInfoVo.setChildrenList(packageChildrenList1(newMallProductTypeInfoVo, mallProductTypeInfos));

                // 将子节点VO对象添加到返回列表中
                returnList.add(newMallProductTypeInfoVo);
            }
        }

        // 返回当前节点的所有直接子节点列表
        return returnList;
    }

    private List<MallProductTypeInfoVo> packageChildrenList(MallProductTypeInfoVo mallProductTypeInfoVo, List<MallProductTypeInfo> mallProductTypeInfos) {
        // 获取当前节点的ID作为父节点ID
        Long parentId = mallProductTypeInfoVo.getId();

        // 使用Stream流处理商品类型信息列表，筛选出所有符合父节点ID的子节点，并转换为VO对象列表
        List<MallProductTypeInfoVo> collect = mallProductTypeInfos.stream()
                .filter(item -> parentId.equals(item.getParentId())) // 过滤出符合父节点ID的商品类型信息
                .map(newItem -> {
                    // 创建新的商品类型信息VO对象，并复制属性
                    MallProductTypeInfoVo productTypeInfoVo = new MallProductTypeInfoVo();
                    BeanUtils.copyProperties(newItem, productTypeInfoVo);

                    // 递归调用，为当前子节点设置其子节点列表
                    productTypeInfoVo.setChildrenList(packageChildrenList(productTypeInfoVo, mallProductTypeInfos));

                    return productTypeInfoVo; // 返回处理后的VO对象
                })
                .collect(Collectors.toList()); // 将流转换为List集合

        return collect; // 返回包含所有子节点的VO对象列表
    }
}
